home *** CD-ROM | disk | FTP | other *** search
/ Aminet 35 / Aminet 35 (2000)(Schatztruhe)[!][Feb 2000].iso / Aminet / comm / tcp / samba_2.0.6.lha / source / amiga.diffs next >
Encoding:
Text File  |  1999-12-03  |  16.4 KB  |  673 lines
  1. *** include/includes.h    Wed Nov 10 21:36:00 1999
  2. --- /new/include/includes.h    Tue Nov 16 19:32:45 1999
  3. ***************
  4. *** 21,26 ****
  5. --- 21,36 ----
  6.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  7.   */
  8.   
  9. + #ifdef AMIGA
  10. + /* This type definition clashes with one
  11. +  * used in the Samba code, which is why
  12. +  * we hide it.
  13. +  */
  14. + #define BOOL __BOOL
  15. + #include <exec/types.h>
  16. + #undef BOOL
  17. + #endif /* AMIGA */
  18. + 
  19.   #ifndef NO_CONFIG_H /* for some tests */
  20.   #include "config.h"
  21.   #endif
  22. ***************
  23. *** 847,852 ****
  24. --- 857,873 ----
  25.   
  26.   /* yuck, I'd like a better way of doing this */
  27.   #define DIRP_SIZE (256 + 32)
  28. + 
  29. + #ifdef AMIGA
  30. + /* Remap a couple of library routines. */
  31. + #include "amiga.h"
  32. + 
  33. + /* These clash with local definitions in "smbd/ipc.c",
  34. +  * which is why we undefine them.
  35. +  */
  36. + #undef ACCESS_READ
  37. + #undef ACCESS_WRITE
  38. + #endif /* AMIGA */
  39.   
  40.   /*
  41.    * glibc on linux doesn't seem to have MSG_WAITALL
  42. *** lib/smbrun.c    Tue Jul 20 20:25:09 1999
  43. --- /new/lib/smbrun.c    Tue Nov 16 19:32:45 1999
  44. ***************
  45. *** 92,97 ****
  46. --- 92,100 ----
  47.       set_inherited_process_capability(KERNEL_OPLOCK_CAPABILITY, False);
  48.   
  49.   #ifndef HAVE_EXECL
  50. + #ifdef AMIGA
  51. +     return(amiga_smbrun(cmd,outfile,shared));
  52. + #else
  53.       int ret;
  54.       pstring syscmd;  
  55.       char *path = lp_smbrun();
  56. ***************
  57. *** 113,118 ****
  58. --- 116,122 ----
  59.       ret = system(syscmd);
  60.       DEBUG(5,("gave %d\n",ret));
  61.       return(ret);
  62. + #endif /* AMIGA */
  63.   #else
  64.       /* in this newer method we will exec /bin/sh with the correct
  65.          arguments, after first setting stdout to point at the file */
  66. *** lib/snprintf.c    Wed Oct 13 00:26:49 1999
  67. --- /new/lib/snprintf.c    Tue Nov 16 19:32:48 1999
  68. ***************
  69. *** 49,54 ****
  70. --- 49,59 ----
  71.    *    fixed handling of %.0f
  72.    *    added test for HAVE_LONG_DOUBLE
  73.    *
  74. +  *  Olaf Barthel <olsen@sourcery.han.de> 15-Oct-99
  75. +  *    Implemented the missing 'f' and 'g' floating point output
  76. +  *    formats; also fixed handling of floating point numbers
  77. +  *    like "0.01" which would always come out as "0.1".
  78. +  *
  79.    **************************************************************/
  80.   
  81.   #include "config.h"
  82. ***************
  83. *** 59,64 ****
  84. --- 64,73 ----
  85.   
  86.   #if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF)
  87.   
  88. + #ifdef AMIGA
  89. + #include <math.h>
  90. + #endif /* AMIGA */
  91. + 
  92.   /* Define this as a fall through, HAVE_STDARG_H is probably already set */
  93.   
  94.   #define HAVE_VARARGS_H
  95. ***************
  96. *** 107,113 ****
  97.   static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
  98.               long value, int base, int min, int max, int flags);
  99.   static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
  100. !            LDOUBLE fvalue, int min, int max, int flags);
  101.   static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c );
  102.   
  103.   /*
  104. --- 116,122 ----
  105.   static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
  106.               long value, int base, int min, int max, int flags);
  107.   static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
  108. !            LDOUBLE fvalue, int min, int max, int flags, char ch);
  109.   static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c );
  110.   
  111.   /*
  112. ***************
  113. *** 326,332 ****
  114.       else
  115.         fvalue = va_arg (args, double);
  116.       /* um, floating point? */
  117. !     fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
  118.       break;
  119.         case 'E':
  120.       flags |= DP_F_UP;
  121. --- 335,341 ----
  122.       else
  123.         fvalue = va_arg (args, double);
  124.       /* um, floating point? */
  125. !     fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags, ch);
  126.       break;
  127.         case 'E':
  128.       flags |= DP_F_UP;
  129. ***************
  130. *** 335,340 ****
  131. --- 344,351 ----
  132.         fvalue = va_arg (args, LDOUBLE);
  133.       else
  134.         fvalue = va_arg (args, double);
  135. +     /* um, floating point? */
  136. +     fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags, ch);
  137.       break;
  138.         case 'G':
  139.       flags |= DP_F_UP;
  140. ***************
  141. *** 343,348 ****
  142. --- 354,361 ----
  143.         fvalue = va_arg (args, LDOUBLE);
  144.       else
  145.         fvalue = va_arg (args, double);
  146. +     /* um, floating point? */
  147. +     fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags, ch);
  148.       break;
  149.         case 'c':
  150.       dopr_outch (buffer, &currlen, maxlen, va_arg (args, int));
  151. ***************
  152. *** 577,584 ****
  153.   }
  154.   
  155.   static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
  156. !            LDOUBLE fvalue, int min, int max, int flags)
  157.   {
  158.     int signvalue = 0;
  159.     LDOUBLE ufvalue;
  160.   #ifndef HAVE_FCVT
  161. --- 590,604 ----
  162.   }
  163.   
  164.   static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
  165. !            LDOUBLE fvalue, int min, int max, int flags, char ch)
  166.   {
  167. +   enum /* olsen: output formats to be used below. */
  168. +   {
  169. +     FORMAT_f,
  170. +     FORMAT_g,
  171. +     FORMAT_e
  172. +   };
  173. + 
  174.     int signvalue = 0;
  175.     LDOUBLE ufvalue;
  176.   #ifndef HAVE_FCVT
  177. ***************
  178. *** 593,599 ****
  179. --- 613,621 ----
  180.   # ifdef HAVE_FCVTL
  181.     extern char *fcvtl(long double value, int ndigit, int *decpt, int *sign);
  182.   # else
  183. + #ifndef AMIGA
  184.     extern char *fcvt(double value, int ndigit, int *decpt, int *sign);
  185. + #endif /* AMIGA */
  186.   # endif
  187.   #endif
  188.     int iplace = 0;
  189. ***************
  190. *** 603,609 ****
  191.     int caps = 0;
  192.     long intpart;
  193.     long fracpart;
  194. !   
  195.     /* 
  196.      * AIX manpage says the default is 0, but Solaris says the default
  197.      * is 6, and sprintf on AIX defaults to 6
  198. --- 625,635 ----
  199.     int caps = 0;
  200.     long intpart;
  201.     long fracpart;
  202. !   int exponent;
  203. !   int exponentLen;
  204. !   int outputFmt;
  205. !   int decimalPointLen;
  206. ! 
  207.     /* 
  208.      * AIX manpage says the default is 0, but Solaris says the default
  209.      * is 6, and sprintf on AIX defaults to 6
  210. ***************
  211. *** 622,627 ****
  212. --- 648,696 ----
  213.         if (flags & DP_F_SPACE)
  214.       signvalue = ' ';
  215.   
  216. +   /* olsen: determine the output format. */
  217. +   if(ch == 'g' || ch == 'G')
  218. +     outputFmt = FORMAT_g;
  219. +   else if (ch == 'e' || ch == 'E')
  220. +     outputFmt = FORMAT_e;
  221. +   else
  222. +     outputFmt = FORMAT_f;
  223. + 
  224. +   /* olsen: calculate the exponent */
  225. +   exponent = 0;
  226. +   if(ufvalue > 0.0 && outputFmt != FORMAT_f)
  227. +   {
  228. +     LDOUBLE value = ufvalue;
  229. + 
  230. +     /* Make sure that the integer part
  231. +      * comes out as a single digit.
  232. +      */
  233. +     if(value < 1.0)
  234. +     {
  235. +       do
  236. +       {
  237. +         value *= 10.0;
  238. +         exponent--;
  239. +       }
  240. +       while(value < 1.0);
  241. +     }
  242. +     else if(value > 10.0)
  243. +     {
  244. +       do
  245. +       {
  246. +         value /= 10.0;
  247. +         exponent++;
  248. +       }
  249. +       while(value > 10.0);
  250. +     }
  251. + 
  252. +     /* Don't change the base unless we are to output
  253. +      * the number in scientific format.
  254. +      */
  255. +     if((outputFmt == FORMAT_e) || (outputFmt == FORMAT_g && exponent < -4))
  256. +       ufvalue = value;
  257. +   }
  258. + 
  259.   #if 0
  260.     if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
  261.   #endif
  262. ***************
  263. *** 659,674 ****
  264.       intpart = (intpart / 10);
  265.     } while(intpart && (iplace < 20));
  266.     if (iplace == 20) iplace--;
  267. !   iconvert[iplace] = 0;
  268.   
  269.     /* Convert fractional part */
  270.     do {
  271.       fconvert[fplace++] =
  272.         (caps? "0123456789ABCDEF":"0123456789abcdef")[fracpart % 10];
  273.       fracpart = (fracpart / 10);
  274. !   } while(fracpart && (fplace < 20));
  275.     if (fplace == 20) fplace--;
  276. !   fconvert[fplace] = 0;
  277.   #else  /* use fcvt() */
  278.     if (max > 310)
  279.       max = 310;
  280. --- 728,752 ----
  281.       intpart = (intpart / 10);
  282.     } while(intpart && (iplace < 20));
  283.     if (iplace == 20) iplace--;
  284. !   iconvert[iplace] = '\0';
  285.   
  286.     /* Convert fractional part */
  287.     do {
  288.       fconvert[fplace++] =
  289.         (caps? "0123456789ABCDEF":"0123456789abcdef")[fracpart % 10];
  290.       fracpart = (fracpart / 10);
  291. !   } while(fracpart != 0 && (fplace < 20));
  292. ! 
  293. !   /* olsen: we need to make up for numbers like 0.01
  294. !    *        which would come out as "0.1" unless
  295. !    *        we add a few padding zeroes.
  296. !    */
  297. !   while(fplace < 20 && fplace < max)
  298. !     fconvert[fplace++] = '0';
  299. ! 
  300.     if (fplace == 20) fplace--;
  301. !   fconvert[fplace] = '\0';
  302. ! 
  303.   #else  /* use fcvt() */
  304.     if (max > 310)
  305.       max = 310;
  306. ***************
  307. *** 716,723 ****
  308.       }
  309.   #endif /* fcvt */
  310.     
  311.     /* -1 for decimal point, another -1 if we are printing a sign */
  312. !   padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); 
  313.     zpadlen = max - fplace;
  314.     if (zpadlen < 0)
  315.       zpadlen = 0;
  316. --- 794,863 ----
  317.       }
  318.   #endif /* fcvt */
  319.     
  320. +   /* olsen: eliminate trailing zeroes. */
  321. +   decimalPointLen = (max > 0) ? 1 : 0;
  322. +   exponentLen = 0;
  323. +   if(outputFmt == FORMAT_g)
  324. +   {
  325. +     int i,numTrailingZeroes;
  326. + 
  327. +     /* Count the number of trailing zeroes. */
  328. +     numTrailingZeroes = 0;
  329. +     for(i = 0 ; i < fplace ; i++)
  330. +     {
  331. +       if(fconvert[i] == '0')
  332. +         numTrailingZeroes++;
  333. +       else
  334. +         break;
  335. +     }
  336. + 
  337. +     /* If there are any, remove them. */
  338. +     if(numTrailingZeroes > 0)
  339. +     {
  340. +       /* Remove the zeroes, if necessary.
  341. +        * Otherwise, just forget that we
  342. +        * had any digits in the fractional
  343. +        * part.
  344. +        */
  345. +       if(numTrailingZeroes != fplace)
  346. +       {
  347. +         for(i = 0 ; i < fplace-numTrailingZeroes ; i++)
  348. +           fconvert[i] = fconvert[numTrailingZeroes+i];
  349. +       }
  350. + 
  351. +       fplace -= numTrailingZeroes;
  352. +       fconvert[fplace] = '\0';
  353. + 
  354. +       /* Don't print the decimal point if
  355. +        * there is nothing to follow it.
  356. +        */
  357. +       if(fplace == 0)
  358. +         decimalPointLen = 0;
  359. +     }
  360. + 
  361. +     /* Switch to scientific output format
  362. +      * if the exponent is too small.
  363. +      */
  364. +     if(exponent < -4)
  365. +     {
  366. +       /* Two digits for the "e+" and
  367. +        * at least two digits for the number
  368. +        * to follow the sign.
  369. +        */
  370. +       exponentLen = (int)log10((LDOUBLE)exponent) + 2;
  371. +       if(exponentLen < 4)
  372. +         exponentLen = 4;
  373. +     }
  374. +   }
  375. +   else if(outputFmt == FORMAT_e)
  376. +   {
  377. +     exponentLen = (int)log10((LDOUBLE)exponent) + 2;
  378. +     if(exponentLen < 4)
  379. +       exponentLen = 4;
  380. +   }
  381. + 
  382.     /* -1 for decimal point, another -1 if we are printing a sign */
  383. !   padlen = min - iplace - max - decimalPointLen - ((signvalue) ? 1 : 0); 
  384.     zpadlen = max - fplace;
  385.     if (zpadlen < 0)
  386.       zpadlen = 0;
  387. ***************
  388. *** 726,731 ****
  389. --- 866,875 ----
  390.     if (flags & DP_F_MINUS) 
  391.       padlen = -padlen; /* Left Justifty */
  392.   
  393. +   /* olsen: eliminate trailing zeroes. */
  394. +   if(outputFmt == FORMAT_g)
  395. +     zpadlen = 0;
  396. + 
  397.     if ((flags & DP_F_ZERO) && (padlen > 0)) 
  398.     {
  399.       if (signvalue) 
  400. ***************
  401. *** 760,766 ****
  402.      * Decimal point.  This should probably use locale to find the correct
  403.      * char to print out.
  404.      */
  405. !   if (max > 0) {
  406.         dopr_outch (buffer, currlen, maxlen, '.');
  407.   
  408.         while (fplace > 0) 
  409. --- 904,910 ----
  410.      * Decimal point.  This should probably use locale to find the correct
  411.      * char to print out.
  412.      */
  413. !   if (max > 0 && decimalPointLen > 0) {
  414.         dopr_outch (buffer, currlen, maxlen, '.');
  415.   
  416.         while (fplace > 0) 
  417. ***************
  418. *** 773,778 ****
  419. --- 917,951 ----
  420.       --zpadlen;
  421.     }
  422.   
  423. +   /* olsen: output the exponent */
  424. +   if(exponentLen > 0)
  425. +   {
  426. +     char expChars[10];
  427. +     int numExpChars;
  428. +     int i;
  429. + 
  430. +     dopr_outch (buffer, currlen, maxlen, caps?'E':'e');
  431. +     if(exponent < 0)
  432. +     {
  433. +       dopr_outch (buffer, currlen, maxlen, '-');
  434. +       exponent = (-exponent);
  435. +     }
  436. +     else
  437. +     {
  438. +       dopr_outch (buffer, currlen, maxlen, '+');
  439. +     }
  440. + 
  441. +     numExpChars = 0;
  442. +     for(i = 0 ; i < exponentLen-2 && i < sizeof(expChars)-1 ; i++)
  443. +     {
  444. +       expChars[numExpChars++] = '0' + (exponent % 10);
  445. +       exponent /= 10;
  446. +     }
  447. + 
  448. +     while(numExpChars > 0)
  449. +       dopr_outch (buffer, currlen, maxlen, expChars[--numExpChars]);
  450. +   }
  451. + 
  452.     while (padlen < 0) 
  453.     {
  454.       dopr_outch (buffer, currlen, maxlen, ' ');
  455. ***************
  456. *** 848,857 ****
  457.       "%3.2f",
  458.       "%.0f",
  459.       "%.1f",
  460.       NULL
  461.     };
  462.     double fp_nums[] = { -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996, 
  463. !     0.9996, 1.996, 4.136, 6442452944.1234, 0};
  464.     char *int_fmt[] = {
  465.       "%-1.5d",
  466.       "%1.5d",
  467. --- 1021,1059 ----
  468.       "%3.2f",
  469.       "%.0f",
  470.       "%.1f",
  471. + 
  472. +     "%-1.5g",
  473. +     "%1.5g",
  474. +     "%123.9g",
  475. +     "%10.5g",
  476. +     "% 10.5g",
  477. +     "%+22.9g",
  478. +     "%+4.9g",
  479. +     "%01.3g",
  480. +     "%4g",
  481. +     "%3.1g",
  482. +     "%3.2g",
  483. +     "%.0g",
  484. +     "%.1g",
  485. + 
  486. +     "%-1.5e",
  487. +     "%1.5e",
  488. +     "%123.9e",
  489. +     "%10.5e",
  490. +     "% 10.5e",
  491. +     "%+22.9e",
  492. +     "%+4.9e",
  493. +     "%01.3e",
  494. +     "%4e",
  495. +     "%3.1e",
  496. +     "%3.2e",
  497. +     "%.0e",
  498. +     "%.1e",
  499. + 
  500.       NULL
  501.     };
  502.     double fp_nums[] = { -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996, 
  503. !     0.9996, 1.996, 4.136, 644245294.1234, 0};
  504.     char *int_fmt[] = {
  505.       "%-1.5d",
  506.       "%1.5d",
  507. ***************
  508. *** 900,904 ****
  509.       }
  510.     printf ("%d tests failed out of %d.\n", fail, num);
  511.   }
  512. ! #endif /* SNPRINTF_TEST */
  513. ! 
  514. --- 1102,1105 ----
  515.       }
  516.     printf ("%d tests failed out of %d.\n", fail, num);
  517.   }
  518. ! #endif /* TEST_SNPRINTF */
  519. *** lib/util.c    Wed Nov 10 21:36:02 1999
  520. --- /new/lib/util.c    Tue Nov 16 19:32:49 1999
  521. ***************
  522. *** 1582,1587 ****
  523. --- 1582,1594 ----
  524.   ****************************************************************************/
  525.   void become_daemon(void)
  526.   {
  527. +     #ifdef AMIGA
  528. +     {
  529. +         DEBUG(2,("Warning: become_daemon() not done.\n"));
  530. +         return;
  531. +     }
  532. +     #endif /* AMIGA */
  533. + 
  534.       if (fork()) {
  535.           _exit(0);
  536.       }
  537. *** lib/interface.c    Wed Oct 13 00:26:48 1999
  538. --- /new/lib/interface.c    Sat Nov 20 16:01:23 1999
  539. ***************
  540. *** 234,243 ****
  541.   
  542.       n = get_interfaces(ifaces, MAX_INTERFACES);
  543.   
  544. !     if (n != total_probed ||
  545. !         memcmp(ifaces, probed_ifaces, sizeof(ifaces[0])*n)) {
  546. !         return True;
  547.       }
  548.       
  549.       return False;
  550.   }
  551. --- 234,255 ----
  552.   
  553.       n = get_interfaces(ifaces, MAX_INTERFACES);
  554.   
  555. !     /* olsen: probed_ifaces can be NULL! */
  556. !     #ifdef AMIGA
  557. !     {
  558. !         if (n != total_probed ||
  559. !             (probed_ifaces != NULL && memcmp(ifaces, probed_ifaces, sizeof(ifaces[0])*n))) {
  560. !             return True;
  561. !         }
  562.       }
  563. +     #else
  564. +     {
  565. +         if (n != total_probed ||
  566. +             memcmp(ifaces, probed_ifaces, sizeof(ifaces[0])*n)) {
  567. +             return True;
  568. +         }
  569. +     }
  570. +     #endif
  571.       
  572.       return False;
  573.   }
  574. *** lib/interfaces.c    Fri Sep 24 18:42:05 1999
  575. --- /new/lib/interfaces.c    Fri Dec 03 09:14:02 1999
  576. ***************
  577. *** 331,336 ****
  578. --- 331,345 ----
  579.       return total;
  580.   }
  581.   
  582. + #elif defined(AMIGA)
  583. + 
  584. + static int _get_interfaces(struct iface_struct *ifaces, int max_interfaces)
  585. + {
  586. +     extern int amiga_get_interfaces(struct iface_struct * ifaces,int max_interfaces);
  587. + 
  588. +     return(amiga_get_interfaces(ifaces,max_interfaces));
  589. + }
  590. + 
  591.   #else /* a dummy version */
  592.   static int _get_interfaces(struct iface_struct *ifaces, int max_interfaces)
  593.   {
  594. *** libsmb/clientgen.c    Wed Nov 10 21:36:03 1999
  595. --- /new/libsmb/clientgen.c    Tue Nov 16 19:32:53 1999
  596. ***************
  597. *** 872,878 ****
  598.           pstrcpy(p,workgroup);
  599.           strupper(p);
  600.           p = skip_string(p,1);
  601. !         pstrcpy(p,"Unix");p = skip_string(p,1);
  602.           pstrcpy(p,"Samba");p = skip_string(p,1);
  603.           set_message(cli->outbuf,13,PTR_DIFF(p,smb_buf(cli->outbuf)),False);
  604.       }
  605. --- 872,886 ----
  606.           pstrcpy(p,workgroup);
  607.           strupper(p);
  608.           p = skip_string(p,1);
  609. !         #ifdef AMIGA
  610. !         {
  611. !           pstrcpy(p,"AmigaOS");p = skip_string(p,1);
  612. !         }
  613. !         #else
  614. !         {
  615. !           pstrcpy(p,"Unix");p = skip_string(p,1);
  616. !         }
  617. !         #endif /* AMIGA */
  618.           pstrcpy(p,"Samba");p = skip_string(p,1);
  619.           set_message(cli->outbuf,13,PTR_DIFF(p,smb_buf(cli->outbuf)),False);
  620.       }
  621. *** smbd/reply.c    Wed Nov 10 21:36:11 1999
  622. --- /new/smbd/reply.c    Tue Nov 16 19:32:54 1999
  623. ***************
  624. *** 955,961 ****
  625.       char *p;
  626.       set_message(outbuf,3,3,True);
  627.       p = smb_buf(outbuf);
  628. !     pstrcpy(p,"Unix"); p = skip_string(p,1);
  629.       pstrcpy(p,"Samba "); pstrcat(p,VERSION); p = skip_string(p,1);
  630.       pstrcpy(p,global_myworkgroup); p = skip_string(p,1);
  631.       set_message(outbuf,3,PTR_DIFF(p,smb_buf(outbuf)),False);
  632. --- 955,969 ----
  633.       char *p;
  634.       set_message(outbuf,3,3,True);
  635.       p = smb_buf(outbuf);
  636. !     #ifdef AMIGA
  637. !     {
  638. !       pstrcpy(p,"AmigaOS"); p = skip_string(p,1);
  639. !     }
  640. !     #else
  641. !     {
  642. !       pstrcpy(p,"Unix"); p = skip_string(p,1);
  643. !     }
  644. !     #endif /* AMIGA */
  645.       pstrcpy(p,"Samba "); pstrcat(p,VERSION); p = skip_string(p,1);
  646.       pstrcpy(p,global_myworkgroup); p = skip_string(p,1);
  647.       set_message(outbuf,3,PTR_DIFF(p,smb_buf(outbuf)),False);
  648. *** web/swat.c    Wed Nov 10 21:36:19 1999
  649. --- /new/web/swat.c    Tue Nov 16 19:32:55 1999
  650. ***************
  651. *** 965,972 ****
  652.       if (!dbf) dbf = stderr;
  653.   
  654.       /* we don't want stderr screwing us up */
  655. !     close(2);
  656. !     open("/dev/null", O_WRONLY);
  657.   
  658.       while ((opt = getopt(argc, argv,"s:a")) != EOF) {
  659.           switch (opt) {
  660. --- 965,976 ----
  661.       if (!dbf) dbf = stderr;
  662.   
  663.       /* we don't want stderr screwing us up */
  664. !     #ifndef AMIGA
  665. !     {
  666. !         close(2);
  667. !         open("/dev/null", O_WRONLY);
  668. !     }
  669. !     #endif /* AMIGA */
  670.   
  671.       while ((opt = getopt(argc, argv,"s:a")) != EOF) {
  672.           switch (opt) {
  673.